package main.dao;

import java.io.Serializable;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.orm.hibernate3.HibernateTemplate;
import org.springframework.stereotype.Repository;

/**
 * DAO基类，其它DAO可以直接继承这个DAO，不但可以复用共用的方法，还可以获得泛型的好处。
 */
@Repository("baseDAO")
public class BaseDAO<T> implements IBaseDAO<T>{
	
//    private Class<T> entityClass;
    @Autowired
    @Qualifier("hibernateTemplate")
    private HibernateTemplate hibernateTemplate;
    /**
     * 通过反射获取子类确定的泛型类
     */
    @SuppressWarnings({ "unchecked", "rawtypes" })
	public BaseDAO() {
/*        Type genType = getClass().getGenericSuperclass();
        Type[] params = ((ParameterizedType) genType).getActualTypeArguments();
        entityClass = (Class<T>) params[0];*/
//        entityClass = (Class<T>)UtilPackage.getSuperClassGenricType(getClass(), 0);
//        entityClass = (Class<T>)getClass();
//        T entity = new T();
//        initialize(entity);
//        entityClass = (Class<T>)entity;
    }

    /**
     * 根据ID加载PO实例
     *
     * @param id
     * @return 返回相应的持久化PO实例
     */
    public T load(Class<T> entityClass, Serializable id) {
        return getHibernateTemplate().load(entityClass, id);
    }

    /**
     * 根据ID获取PO实例
     *
     * @param id
     * @return 返回相应的持久化PO实例
     */
    public T getByID(Class<T> entityClass, Serializable id) {
//    	System.err.println(entityClass.getName());
        return getHibernateTemplate().get(entityClass, id);
    }

    /**
     * 获取PO的所有对象
     *
     * @return
     */
    public List<T> loadAll(Class<T> entityClass) {
        return getHibernateTemplate().loadAll(entityClass);
    }

    /**
     * 保存PO
     *
     * @param entity
     */
    public Integer save(T entity) {
    	Serializable serializable = getHibernateTemplate().save(entity);
    	return (Integer)serializable;
    }

    /**
     * 删除PO
     *
     * @param entity
     * @return 
     */
    public Boolean remove(T entity) {
    	Boolean flag = true;
    	try {
    		getHibernateTemplate().delete(entity);
		} catch (Exception e) {
			flag = false;
		}
        return flag;
    }

    /**
     * 更改PO
     *
     * @param entity
     * @return 
     */
    public Boolean update(T entity) {        
    	Boolean flag = true;
    	try {
    		getHibernateTemplate().update(entity);
		} catch (Exception e) {
			flag = false;
		}
        return flag;
    }

    /**
     * 执行HQL查询
     *
     * @param sql
     * @return 查询结果
     */
    @SuppressWarnings({ "unchecked", "rawtypes" })
	public List findByHQL(String hql) {
        return this.getHibernateTemplate().find(hql);
    }

    /**
     * 执行带参的HQL查询
     *
     * @param sql
     * @param params
     * @return 查询结果
     */
    @SuppressWarnings({ "rawtypes" })
	public List findByHQL(String hql, Object... params) {
        return this.getHibernateTemplate().find(hql,params);
    }

    public List<T> findByExample(T entity){
    	 return this.getHibernateTemplate().findByExample(entity);
    }
    
    /**
     * 对延迟加载的实体PO执行初始化
     * @param entity
     */
    public void initialize(Object entity) {
        this.getHibernateTemplate().initialize(entity);
    }
    
    public HibernateTemplate getHibernateTemplate() {
        return this.hibernateTemplate;
    }

	@Override
	public List<T> getByEntity(T entity) {
		List<T> list = getHibernateTemplate().findByExample(entity);
		return list;
	}
	
}